home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / Resources.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  9.7 KB  |  354 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Resources.p
  3.  
  4.      Contains:    Resource Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Resources;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __RESOURCES__}
  30. {$SETC __RESOURCES__ := 1}
  31.  
  32. {$I+}
  33. {$SETC ResourcesIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __MIXEDMODE__}
  43. {$I MixedMode.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED __FILES__}
  47. {$I Files.p}
  48. {$ENDC}
  49. {    OSUtils.p                                                    }
  50. {        Memory.p                                                }
  51. {    Finder.p                                                    }
  52.  
  53. {$PUSH}
  54. {$ALIGN MAC68K}
  55. {$LibExport+}
  56.  
  57. CONST
  58.     resSysHeap                    = 64;                            {System or application heap?}
  59.     resPurgeable                = 32;                            {Purgeable resource?}
  60.     resLocked                    = 16;                            {Load it in locked?}
  61.     resProtected                = 8;                            {Protected?}
  62.     resPreload                    = 4;                            {Load in on OpenResFile?}
  63.     resChanged                    = 2;                            {Resource changed?}
  64.     mapReadOnly                    = 128;                            {Resource file read-only}
  65.     mapCompact                    = 64;                            {Compact resource file}
  66.     mapChanged                    = 32;                            {Write map out at update}
  67.     resSysRefBit                = 7;                            {reference to system/local reference}
  68.     resSysHeapBit                = 6;                            {In system/in application heap}
  69.     resPurgeableBit                = 5;                            {Purgeable/not purgeable}
  70.     resLockedBit                = 4;                            {Locked/not locked}
  71.     resProtectedBit                = 3;                            {Protected/not protected}
  72.     resPreloadBit                = 2;                            {Read in at OpenResource?}
  73.     resChangedBit                = 1;                            {Existing resource changed since last update}
  74.     mapReadOnlyBit                = 7;                            {is this file read-only?}
  75.     mapCompactBit                = 6;                            {Is a compact necessary?}
  76.     mapChangedBit                = 5;                            {Is it necessary to write map?}
  77.     kResFileNotOpened            = -1;                            {ref num return as error when opening a resource file}
  78.     kSystemResFile                = 0;                            {this is the default ref num to the system file}
  79.  
  80. TYPE
  81.     {
  82.         ResErrProcPtr uses register based parameters on the 68k and cannot
  83.         be written in or called from a high-level language without the help of
  84.         mixed mode or assembly glue.
  85.  
  86.         In:
  87.          => thErr           D0.W
  88.     }
  89.     ResErrProcPtr = Register68kProcPtr;  { register PROCEDURE ResErr(thErr: OSErr); }
  90.     ResErrUPP = UniversalProcPtr;
  91.  
  92. CONST
  93.     uppResErrProcInfo = $00001002; { Register PROCEDURE (2 bytes in D0); }
  94.  
  95. FUNCTION NewResErrProc(userRoutine: ResErrProcPtr): ResErrUPP;
  96.     {$IFC NOT GENERATINGCFM }
  97.     INLINE $2E9F;
  98.     {$ENDC}
  99.  
  100. PROCEDURE CallResErrProc(thErr: OSErr; userRoutine: ResErrUPP);
  101.     {$IFC NOT GENERATINGCFM}
  102.     {To be implemented:  Glue to move parameters into registers.}
  103.     {$ENDC}
  104.  
  105. FUNCTION InitResources: INTEGER;
  106.     {$IFC NOT GENERATINGCFM}
  107.     INLINE $A995;
  108.     {$ENDC}
  109. PROCEDURE RsrcZoneInit;
  110.     {$IFC NOT GENERATINGCFM}
  111.     INLINE $A996;
  112.     {$ENDC}
  113.  
  114. PROCEDURE CloseResFile(refNum: INTEGER);
  115.     {$IFC NOT GENERATINGCFM}
  116.     INLINE $A99A;
  117.     {$ENDC}
  118. FUNCTION ResError: INTEGER;
  119.     {$IFC NOT GENERATINGCFM}
  120.     INLINE $A9AF;
  121.     {$ENDC}
  122. FUNCTION CurResFile: INTEGER;
  123.     {$IFC NOT GENERATINGCFM}
  124.     INLINE $A994;
  125.     {$ENDC}
  126. FUNCTION HomeResFile(theResource: Handle): INTEGER;
  127.     {$IFC NOT GENERATINGCFM}
  128.     INLINE $A9A4;
  129.     {$ENDC}
  130. PROCEDURE CreateResFile(fileName: ConstStr255Param);
  131.     {$IFC NOT GENERATINGCFM}
  132.     INLINE $A9B1;
  133.     {$ENDC}
  134. FUNCTION OpenResFile(fileName: ConstStr255Param): INTEGER;
  135.     {$IFC NOT GENERATINGCFM}
  136.     INLINE $A997;
  137.     {$ENDC}
  138. PROCEDURE UseResFile(refNum: INTEGER);
  139.     {$IFC NOT GENERATINGCFM}
  140.     INLINE $A998;
  141.     {$ENDC}
  142. FUNCTION CountTypes: INTEGER;
  143.     {$IFC NOT GENERATINGCFM}
  144.     INLINE $A99E;
  145.     {$ENDC}
  146. FUNCTION Count1Types: INTEGER;
  147.     {$IFC NOT GENERATINGCFM}
  148.     INLINE $A81C;
  149.     {$ENDC}
  150. PROCEDURE GetIndType(VAR theType: ResType; index: INTEGER);
  151.     {$IFC NOT GENERATINGCFM}
  152.     INLINE $A99F;
  153.     {$ENDC}
  154. PROCEDURE Get1IndType(VAR theType: ResType; index: INTEGER);
  155.     {$IFC NOT GENERATINGCFM}
  156.     INLINE $A80F;
  157.     {$ENDC}
  158. PROCEDURE SetResLoad(load: BOOLEAN);
  159.     {$IFC NOT GENERATINGCFM}
  160.     INLINE $A99B;
  161.     {$ENDC}
  162. FUNCTION CountResources(theType: ResType): INTEGER;
  163.     {$IFC NOT GENERATINGCFM}
  164.     INLINE $A99C;
  165.     {$ENDC}
  166. FUNCTION Count1Resources(theType: ResType): INTEGER;
  167.     {$IFC NOT GENERATINGCFM}
  168.     INLINE $A80D;
  169.     {$ENDC}
  170. FUNCTION GetIndResource(theType: ResType; index: INTEGER): Handle;
  171.     {$IFC NOT GENERATINGCFM}
  172.     INLINE $A99D;
  173.     {$ENDC}
  174. FUNCTION Get1IndResource(theType: ResType; index: INTEGER): Handle;
  175.     {$IFC NOT GENERATINGCFM}
  176.     INLINE $A80E;
  177.     {$ENDC}
  178. FUNCTION GetResource(theType: ResType; theID: INTEGER): Handle;
  179.     {$IFC NOT GENERATINGCFM}
  180.     INLINE $A9A0;
  181.     {$ENDC}
  182. FUNCTION Get1Resource(theType: ResType; theID: INTEGER): Handle;
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $A81F;
  185.     {$ENDC}
  186. FUNCTION GetNamedResource(theType: ResType; name: ConstStr255Param): Handle;
  187.     {$IFC NOT GENERATINGCFM}
  188.     INLINE $A9A1;
  189.     {$ENDC}
  190. FUNCTION Get1NamedResource(theType: ResType; name: ConstStr255Param): Handle;
  191.     {$IFC NOT GENERATINGCFM}
  192.     INLINE $A820;
  193.     {$ENDC}
  194. PROCEDURE LoadResource(theResource: Handle);
  195.     {$IFC NOT GENERATINGCFM}
  196.     INLINE $A9A2;
  197.     {$ENDC}
  198. PROCEDURE ReleaseResource(theResource: Handle);
  199.     {$IFC NOT GENERATINGCFM}
  200.     INLINE $A9A3;
  201.     {$ENDC}
  202. PROCEDURE DetachResource(theResource: Handle);
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $A992;
  205.     {$ENDC}
  206. FUNCTION UniqueID(theType: ResType): INTEGER;
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $A9C1;
  209.     {$ENDC}
  210. FUNCTION Unique1ID(theType: ResType): INTEGER;
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $A810;
  213.     {$ENDC}
  214. FUNCTION GetResAttrs(theResource: Handle): INTEGER;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $A9A6;
  217.     {$ENDC}
  218. PROCEDURE GetResInfo(theResource: Handle; VAR theID: INTEGER; VAR theType: ResType; VAR name: Str255);
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $A9A8;
  221.     {$ENDC}
  222. PROCEDURE SetResInfo(theResource: Handle; theID: INTEGER; name: ConstStr255Param);
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $A9A9;
  225.     {$ENDC}
  226. PROCEDURE AddResource(theData: Handle; theType: ResType; theID: INTEGER; name: ConstStr255Param);
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $A9AB;
  229.     {$ENDC}
  230. FUNCTION GetResourceSizeOnDisk(theResource: Handle): LONGINT;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $A9A5;
  233.     {$ENDC}
  234. FUNCTION GetMaxResourceSize(theResource: Handle): LONGINT;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $A821;
  237.     {$ENDC}
  238. FUNCTION RsrcMapEntry(theResource: Handle): LONGINT;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $A9C5;
  241.     {$ENDC}
  242. PROCEDURE SetResAttrs(theResource: Handle; attrs: INTEGER);
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $A9A7;
  245.     {$ENDC}
  246. PROCEDURE ChangedResource(theResource: Handle);
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $A9AA;
  249.     {$ENDC}
  250. PROCEDURE RemoveResource(theResource: Handle);
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $A9AD;
  253.     {$ENDC}
  254. PROCEDURE UpdateResFile(refNum: INTEGER);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $A999;
  257.     {$ENDC}
  258. PROCEDURE WriteResource(theResource: Handle);
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $A9B0;
  261.     {$ENDC}
  262. PROCEDURE SetResPurge(install: BOOLEAN);
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $A993;
  265.     {$ENDC}
  266. FUNCTION GetResFileAttrs(refNum: INTEGER): INTEGER;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $A9F6;
  269.     {$ENDC}
  270. PROCEDURE SetResFileAttrs(refNum: INTEGER; attrs: INTEGER);
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $A9F7;
  273.     {$ENDC}
  274. FUNCTION OpenRFPerm(fileName: ConstStr255Param; vRefNum: INTEGER; permission: ByteParameter): INTEGER;
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $A9C4;
  277.     {$ENDC}
  278. FUNCTION RGetResource(theType: ResType; theID: INTEGER): Handle;
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $A80C;
  281.     {$ENDC}
  282. {$IFC SystemSevenOrLater }
  283. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $A81A;
  286.     {$ENDC}
  287. {$ELSEC}
  288. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  289. {$ENDC}
  290. {$IFC SystemSevenOrLater }
  291. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $A81B;
  294.     {$ENDC}
  295. {$ELSEC}
  296. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  297. {$ENDC}
  298. FUNCTION FSpOpenResFile({CONST}VAR spec: FSSpec; permission: ByteParameter): INTEGER;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $700D, $AA52;
  301.     {$ENDC}
  302. PROCEDURE FSpCreateResFile({CONST}VAR spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode);
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $700E, $AA52;
  305.     {$ENDC}
  306. {  partial resource calls  }
  307. PROCEDURE ReadPartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $7001, $A822;
  310.     {$ENDC}
  311. PROCEDURE WritePartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $7002, $A822;
  314.     {$ENDC}
  315. PROCEDURE SetResourceSize(theResource: Handle; newSize: LONGINT);
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $7003, $A822;
  318.     {$ENDC}
  319. FUNCTION GetNextFOND(fondHandle: Handle): Handle;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $700A, $A822;
  322.     {$ENDC}
  323. { Use TempInsertROMMap to force the ROM resource map to be
  324.    inserted into the chain in front of the system. Note that
  325.    this call is only temporary - the modified resource chain
  326.    is only used for the next call to the resource manager.
  327.    See IM IV 19 for more information. }
  328. PROCEDURE TempInsertROMMap(tempResLoad: BOOLEAN);
  329. {$IFC OLDROUTINENAMES }
  330. FUNCTION SizeResource(theResource: Handle): LONGINT;
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $A9A5;
  333.     {$ENDC}
  334. FUNCTION MaxSizeRsrc(theResource: Handle): LONGINT;
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $A821;
  337.     {$ENDC}
  338. PROCEDURE RmveResource(theResource: Handle);
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $A9AD;
  341.     {$ENDC}
  342. {$ENDC}
  343.  
  344. {$ALIGN RESET}
  345. {$POP}
  346.  
  347. {$SETC UsingIncludes := ResourcesIncludes}
  348.  
  349. {$ENDC} {__RESOURCES__}
  350.  
  351. {$IFC NOT UsingIncludes}
  352.  END.
  353. {$ENDC}
  354.